Jassif Team Institution

// Union type
function formatId(id: string | number) {
  return `ID: ${id}`;
}

// Intersection type
type User = { name: string } & { id: number };

type Fish = { swim: () => void };
type Bird = { fly: () => void };

function isFish(pet: Fish | Bird): pet is Fish {
  return 'swim' in pet;
}

// Generic function with constraints
function getProperty(obj: T, key: K): T[K] {
  return obj[key];
}

// Generic interface with default type
interface PaginatedResponse {
  data: T[];
  total: number;
  page: number;
  limit: number;
}

// Using generic types with async/await in Node.js
async function fetchData(url: string): Promise {
  const response = await fetch(url);
  return response.json();
}

// Mapped types
type ReadonlyUser = {
  readonly [K in keyof User]: User[K];
};

// Conditional types
type NonNullableUser = NonNullable; // User

// Type inference with conditional types
type GetReturnType = T extends (...args: any[]) => infer R ? R : never;
function getUser() {
  return { id: 1, name: 'Alice' } as const;
}
type UserReturnType = GetReturnType; // { readonly id: 1; readonly name: "Alice"; }

// Type inference with variables
const name = 'Alice'; // TypeScript infers type: string
const age = 30; // TypeScript infers type: number
const active = true; // TypeScript infers type: boolean

// Type inference with arrays
const numbers = [1, 2, 3]; // TypeScript infers type: number[]
const mixed = [1, 'two', true]; // TypeScript infers type: (string | number | boolean)[]

// Type inference with functions
function getUser() {
  return { id: 1, name: 'Alice' }; // Return type inferred as { id: number; name: string; }
}

const user = getUser(); // user inferred as { id: number; name: string; }
console.log(user.name); // Type checking works on inferred properties

// Parameter decorator with metadata
function validateParam(target: any, key: string, index: number) {
  const params = Reflect.getMetadata('design:paramtypes', target, key) || [];
  console.log(`Validating parameter ${index} of ${key} with type ${params[index]?.name}`);
}

// Method decorator with factory
function logExecutionTime(msThreshold = 0) {
  return function (target: any, key: string, descriptor: PropertyDescriptor) {
    const originalMethod = descriptor.value;
    descriptor.value = async function (...args: any[]) {
      const start = Date.now();
      const result = await originalMethod.apply(this, args);
      const duration = Date.now() - start;
      if (duration > msThreshold) {
        console.warn(`[Performance] ${key} took ${duration}ms`);
      }
      return result;
    };
  };
}
class ExampleService {
  @logExecutionTime(100)
  async fetchData(@validateParam url: string) {
    // Implementation
  }
}

// Built-in utility types with examples interface User {
  id: number;
  name: string;
  email?: string;
  createdAt: Date;
}
// Create a type with specific properties as required
type AtLeast = Partial & Pick;
type UserCreateInput = AtLeast; // Only name is required

// Create a type that makes specific properties required
WithRequired = T & { [P in K]-?: T[P] };
type UserWithEmail = WithRequired;

// Extract function return type as a type
type UserFromAPI = Awaited>;

import { EventEmitter } from 'events';

type EventMap = {
  login: (userId: string) => void;
  logout: (userId: string, reason: string) => void;
  error: (error: Error) => void;
};

class TypedEventEmitter void>> {
  private emitter = new EventEmitter();

  on(event: K, listener: T[K]): void {
    this.emitter.on(event as string, listener as any);
  }

  emit(
    event: K,
    ...args: Parameters
  ): boolean {
    return this.emitter.emit(event as string, ...args);
  }
}

// Usage
const userEvents = new TypedEventEmitter();
userEvents.on('login', (userId) => {
  console.log(`User ${userId} logged in`);
});

// TypeScript will show an error for incorrect argument types
// userEvents.emit('login', 123);
// Error: Argument of type 'number' is not assignable to 'string'